home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / graf.cpp < prev    next >
C/C++ Source or Header  |  1994-11-17  |  8KB  |  280 lines
  1. #include "graf.h"
  2.  
  3. void Graf::show(int* x, int* y, int numpoints, int x0, int y0, int no)
  4.     {
  5.     int bar_no = 0;
  6.     for(int num = 0; num < no; num++)
  7.     if(line_type == BAR_GRAF || line_type == BAR_3D_GRAF)
  8.         bar_no++;
  9.     int i;
  10.     drawTool->setcolor(attr);
  11.     drawTool->setlinestyle(SOLID_LINE, 1, 1);
  12.  
  13.     switch(line_type)
  14.     {
  15.     case LINE_GRAF:
  16.         drawTool->moveto(x0 + x[0], y0 - y[0]);
  17.         for(i = 0; i < numpoints; i++)
  18.         drawTool->lineto(x0 + x[i], y0 - y[i]);
  19.         break;
  20.     case MARKER_GRAF:
  21.         drawTool->moveto(x0 + x[0], y0 - y[0]);
  22.         for(i = 0; i < numpoints; i++)
  23.         show_marker(marker_type, loc(x0 + x[i], y0 - y[i]),
  24.                          attr, size);
  25.         break;
  26.     case COMBINED_GRAF:
  27.         drawTool->moveto(x0 + x[0], y0 - y[0]);
  28.         for(i = 0; i < numpoints; i++)
  29.         drawTool->lineto(x0 + x[i], y0 - y[i]);
  30.  
  31.         drawTool->moveto(x0 + x[0], y0 - y[0]);
  32.         for(i = 0; i < numpoints; i++)
  33.         show_marker(marker_type, loc(x0 + x[i], y0 - y[i]),
  34.                          attr, size);
  35.         break;
  36.  
  37.     case BAR_GRAF:
  38.         drawTool->setfillstyle(fill, bak);
  39.         for(i = 0; i < numpoints; i++)
  40.         {
  41.         int st, en;
  42.         st = x0 + x[i] + size * bar_no;
  43.         en = x0 + x[i] + size + size * bar_no;
  44.         st = st < 0 ? 0 : st;
  45.  
  46.         drawTool->bar3d(st, y0 - y[i], en, y0, 0, ON);
  47.         }
  48.         break;
  49.     case BAR_3D_GRAF:
  50.         setfillstyle(fill, bak);
  51.         for(i = 0; i < numpoints; i++)
  52.         {
  53.         int st, en;
  54.         st = x0 + x[i] + size * bar_no;
  55.         en = x0 + x[i] + size + size * bar_no;
  56.         st = st < 0 ? 0 : st;
  57.  
  58.         drawTool->bar3d(st, y0 - y[i], en, y0, size / 2, ON);
  59.         }
  60.         break;
  61.     case STACKED_BAR_GRAF:
  62.         drawTool->setfillstyle(fill, bak);
  63.         for(i = 0; i < numpoints; i++)
  64.         {
  65.         int st, en, flag;
  66.         if(0 != y[4 * i + 2])
  67.             {
  68.             st = x0 + x[i] - size;
  69.             en = x0 + x[i];
  70.             flag = 0;
  71.             }
  72.         else
  73.             {
  74.             st = x0 + x[i];
  75.             en = x0 + x[i] + size;
  76.             flag = 1;
  77.             }
  78.         st = st < 0 ? 0 : st;
  79.  
  80.         if(!flag)
  81.             drawTool->bar3d(st, y0 - y[4 * i + 2],
  82.             en, y0 - y[4 * i], size / 2, OFF);
  83.         else
  84.             drawTool->bar3d(st, y0 - y[4 * i + 3],
  85.             en, y0 - y[4 * i + 1], size / 2, ON);
  86.         }
  87.         break;
  88.  
  89.     }
  90.     }
  91. /////////////////////////////
  92. void Graf::show_marker(int type, loc pos, int attr, int size)
  93.     {
  94.     drawTool->setcolor(attr);
  95.     drawTool->setfillstyle(SOLID_FILL, attr);
  96.     switch(type)
  97.     {
  98.     case BAR:
  99.         int points[] = { pos.X - size, pos.Y - size,
  100.                  pos.X + size, pos.Y - size,
  101.                  pos.X + size, pos.Y + size,
  102.                  pos.X - size, pos.Y + size,
  103.                  pos.X - size, pos.Y - size };
  104.         drawTool->fillpoly(4, points);
  105.         break;
  106.     case CIRCLE:
  107.         int points9[] = { pos.X - size, pos.Y,
  108.                  pos.X - size/2, pos.Y - size,
  109.                  pos.X + size/2, pos.Y - size,
  110.                  pos.X + size, pos.Y,
  111.                  pos.X + size/2, pos.Y + size,
  112.                  pos.X - size/2, pos.Y + size,
  113.                  pos.X - size, pos.Y };
  114.         drawTool->fillpoly(7, points9);
  115.         break;
  116.     case TRIANGLE:
  117.         int points7[] = { pos.X - size, pos.Y + size,
  118.                  pos.X + size, pos.Y + size,
  119.                  pos.X, pos.Y - size,
  120.                  pos.X - size, pos.Y + size };
  121.         drawTool->fillpoly(4, points7);
  122.         break;
  123.     case STAR5:
  124.         int points1[] = { pos.X - 2 * size / 3, pos.Y + size,
  125.                   pos.X, pos.Y + size / 3,
  126.                   pos.X + 2 * size / 3, pos.Y + size,
  127.                   pos.X + size / 2, pos.Y + size / 4,
  128.                   pos.X + size, pos.Y - size / 3,
  129.                   pos.X + size / 3, pos.Y - size / 3,
  130.                   pos.X, pos.Y - size,
  131.                   pos.X - size / 3, pos.Y - size / 3,
  132.                   pos.X - size, pos.Y - size / 3,
  133.                   pos.X - size / 2, pos.Y + size / 4,
  134.                   pos.X - 2 * size / 3, pos.Y + size
  135.                   };
  136.         drawTool->fillpoly(11, points1);
  137.         break;
  138.     case STAR6:
  139.         int points2[] = { pos.X, pos.Y - size,
  140.                   pos.X + size / 2, pos.Y - size / 2,
  141.                   pos.X + size, pos.Y - size / 2,
  142.                   pos.X + 3 * size / 4, pos.Y,
  143.                   pos.X + size, pos.Y + size / 2,
  144.                   pos.X + size / 2, pos.Y + size / 2,
  145.                   pos.X, pos.Y + size,
  146.                   pos.X - size / 2, pos.Y + size / 2,
  147.                   pos.X - size, pos.Y + size / 2,
  148.                   pos.X - 3 * size / 4, pos.Y,
  149.                   pos.X - size, pos.Y - size / 2,
  150.                   pos.X - size / 2, pos.Y - size / 2,
  151.                   pos.X, pos.Y - size };
  152.         drawTool->fillpoly(13, points2);
  153.         break;
  154.     case NONE:
  155.         drawTool->putpixel(pos.X, pos.Y);
  156.         break;
  157.     case CROSS:
  158.         int points8[] = { pos.X - size/2, pos.Y - size,
  159.                  pos.X + size/2, pos.Y - size,
  160.                  pos.X + size/2, pos.Y + size,
  161.                  pos.X - size/2, pos.Y + size,
  162.                  pos.X - size/2, pos.Y - size };
  163.         drawTool->fillpoly(5, points8);
  164.         int points10[] = { pos.X - size, pos.Y - size/2,
  165.                  pos.X + size, pos.Y - size/2,
  166.                  pos.X + size, pos.Y + size/2,
  167.                  pos.X - size, pos.Y + size/2,
  168.                  pos.X - size, pos.Y - size/2 };
  169.         drawTool->fillpoly(5, points10);
  170.         break;
  171.     case X_CROSS:
  172.         int points3[] = { pos.X, pos.Y - size / 2,
  173.                   pos.X + size / 2, pos.Y - size,
  174.                   pos.X + size, pos.Y - size / 2,
  175.                   pos.X + size / 2, pos.Y,
  176.                   pos.X + size, pos.Y + size / 2,
  177.                   pos.X + size / 2, pos.Y + size,
  178.                   pos.X, pos.Y + size / 2,
  179.                   pos.X - size / 2, pos.Y + size,
  180.                   pos.X - size, pos.Y + size / 2,
  181.                   pos.X - size / 2, pos.Y,
  182.                   pos.X - size, pos.Y - size / 2,
  183.                   pos.X - size / 2, pos.Y - size,
  184.                   pos.X, pos.Y - size / 2 };
  185.         drawTool->fillpoly(13, points3);
  186.         break;
  187.  
  188.     case DIAMOND:
  189.         int points4[] = { pos.X, pos.Y - size,
  190.                   pos.X + size, pos.Y,
  191.                   pos.X, pos.Y + size,
  192.                   pos.X - size, pos.Y,
  193.                   pos.X, pos.Y - size };
  194.         drawTool->fillpoly(5, points4);
  195.         break;
  196.     case TRIANGLE2:
  197.         int points5[] = { pos.X - size, pos.Y + size,
  198.                  pos.X + size, pos.Y + size,
  199.                  pos.X, pos.Y - size,
  200.                  pos.X - size, pos.Y + size };
  201.         drawTool->drawpoly(4, points5);
  202.         break;
  203.     case BAR2:
  204.         drawTool->rectangle(pos.X - size, pos.Y - size, pos.X + size, pos.Y + size);
  205.         break;
  206.     case CIRCLE2:
  207.         int points11[] = { pos.X - size, pos.Y,
  208.                  pos.X - size/2, pos.Y - size,
  209.                  pos.X + size/2, pos.Y - size,
  210.                  pos.X + size, pos.Y,
  211.                  pos.X + size/2, pos.Y + size,
  212.                  pos.X - size/2, pos.Y + size,
  213.                  pos.X - size, pos.Y };
  214.         drawTool->drawpoly(7, points11);
  215.         break;
  216.     default:
  217.         break;
  218.     }
  219.     }
  220.  
  221. /*
  222. void main()
  223.     {
  224.     int gdriver = DETECT, gmode;
  225.     initgraph(&gdriver, &gmode, "");
  226.  
  227.     drawTool = new KH_Paint();   // See KHPAINT.H
  228.     Graf g;
  229.     g.show_marker(BAR, loc(20, 100), YELLOW, 8);
  230.     g.show_marker(CIRCLE, loc(40, 100), YELLOW, 8);
  231.     g.show_marker(TRIANGLE, loc(60, 100), YELLOW, 8);
  232.     g.show_marker(STAR5, loc(80, 100), YELLOW, 8);
  233.     g.show_marker(NONE, loc(100, 100), YELLOW, 8);
  234.     g.show_marker(STAR6, loc(120, 100), YELLOW, 8);
  235.     g.show_marker(CROSS, loc(140, 100), YELLOW, 8);
  236.     g.show_marker(X_CROSS, loc(160, 100), YELLOW, 8);
  237.     g.show_marker(DIAMOND, loc(180, 100), YELLOW, 8);
  238.     g.show_marker(TRIANGLE2, loc(200, 100), YELLOW, 8);
  239.     g.show_marker(BAR2, loc(220, 100), YELLOW, 8);
  240.     g.show_marker(CIRCLE2, loc(240, 100), YELLOW, 8);
  241.     delete drawTool;
  242.  
  243.     closegraph();
  244.     }
  245. */
  246.  
  247. /*
  248. void main()
  249.     {
  250.     int gdriver = DETECT, gmode;
  251.     initgraph(&gdriver, &gmode, "");
  252.  
  253.     drawTool = new KH_Paint();   // See KHPAINT.H
  254.  
  255.     int x[] = { -50, -25, 0, 25, 50 };
  256.     int y[] = { -50, 30, -10, 20, 0 };
  257.  
  258.     Graf g(BAR, LINE_GRAF, LIGHTGREEN, RED, 4, SLASH_FILL);
  259.     g.show(x, y, 5, 60, 60);
  260.  
  261.     setviewport(120, 0, 240, 240, 1);
  262.     g.set_type(BAR, MARKER_GRAF, LIGHTGREEN, RED, 4, SLASH_FILL);
  263.     g.show(x, y, 5, 60, 60);
  264.  
  265.     setviewport(240, 0, 360, 240, 1);
  266.     g.set_type(BAR, COMBINED_GRAF, LIGHTGREEN, RED, 4, SLASH_FILL);
  267.     g.show(x, y, 5, 60, 60);
  268.  
  269.     setviewport(360, 0, 480, 240, 1);
  270.     g.set_type(BAR, BAR_GRAF, LIGHTGREEN, RED, 12, SLASH_FILL);
  271.     g.show(x, y, 5, 60, 60);
  272.  
  273.     setviewport(500, 0, 630, 240, 1);
  274.     g.set_type(BAR, BAR_3D_GRAF, LIGHTGREEN, RED, 12, SLASH_FILL);
  275.     g.show(x, y, 5, 60, 60);
  276.  
  277.     delete drawTool;
  278.     closegraph();
  279.     }
  280. */